response, _ := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("Explain quantum computing."),
    ai.WithUse(
        Logger{Prefix: "[trace]"},
        SomeOtherMiddleware{},
    ),
)

type Logger struct {
    Prefix string `json:"prefix,omitempty"`
}

func (Logger) Name() string { return "mine/logger" }

func (l Logger) New(ctx context.Context) (*ai.Hooks, error) {
    return &ai.Hooks{
        WrapModel: func(ctx context.Context, p *ai.ModelParams, next ai.ModelNext) (*ai.ModelResponse, error) {
            start := time.Now()
            resp, err := next(ctx, p)
            log.Printf("%s model call took %s", l.Prefix, time.Since(start))
            return resp, err
        },
    }, nil
}

ai.WithUse(ai.MiddlewareFunc(func(ctx context.Context) (*ai.Hooks, error) {
    return &ai.Hooks{
        WrapModel: func(ctx context.Context, p *ai.ModelParams, next ai.ModelNext) (*ai.ModelResponse, error) {
            log.Printf("model call")
            return next(ctx, p)
        },
    }, nil
}))

type MyPlugin struct{
    client *http.Client
}

func (p *MyPlugin) Name() string                          { return "myplugin" }
func (p *MyPlugin) Init(ctx context.Context) []api.Action { return nil }

func (p *MyPlugin) Middlewares(ctx context.Context) ([]*ai.MiddlewareDesc, error) {
    return []*ai.MiddlewareDesc{
        ai.NewMiddleware("description of my middleware", Logger{client: p.client}),
    }, nil
}

// A middleware is identified by a stable name and produces a fresh hooks
// bundle for each Generate() call.
type Middleware interface {
    Name() string
    New(ctx context.Context) (*Hooks, error)
}

type Hooks struct {
    Tools        []Tool
    WrapGenerate func(ctx context.Context, params *GenerateParams, next GenerateNext) (*ModelResponse, error)
    WrapModel    func(ctx context.Context, params *ModelParams, next ModelNext) (*ModelResponse, error)
    WrapTool     func(ctx context.Context, params *ToolParams, next ToolNext) (*MultipartToolResponse, error)
}

// GenerateParams holds params for the WrapGenerate hook.
type GenerateParams struct {
    Options      *GenerateActionOptions // original options passed to Generate
    Request      *ModelRequest          // current model request with accumulated messages
    Iteration    int                    // zero-indexed tool-loop iteration
    MessageIndex int                    // next index for streamed response chunks
    Callback     ModelStreamCallback    // streaming callback, nil if not streaming
}

// ModelParams holds params for the WrapModel hook.
type ModelParams struct {
    Request  *ModelRequest
    Callback ModelStreamCallback
}

// ToolParams holds params for the WrapTool hook.
type ToolParams struct {
    Request *ToolRequest
    Tool    Tool
}

// Chain continuation functions invoked by hooks to pass control to the next layer.
type GenerateNext = func(ctx context.Context, params *GenerateParams) (*ModelResponse, error)
type ModelNext    = func(ctx context.Context, params *ModelParams) (*ModelResponse, error)
type ToolNext     = func(ctx context.Context, params *ToolParams) (*MultipartToolResponse, error)

// NewMiddleware constructs a descriptor without registering it. The prototype
// supplies both the registered name (via its Name() method) and any plugin-
// level state that should flow into JSON-dispatched invocations via unexported
// fields preserved by value-copy.
func NewMiddleware[M Middleware](description string, prototype M) *MiddlewareDesc

// DefineMiddleware creates and registers a middleware descriptor.
func DefineMiddleware[M Middleware](r api.Registry, description string, prototype M) *MiddlewareDesc

// LookupMiddleware returns the registered middleware descriptor with the given name.
func LookupMiddleware(r api.Registry, name string) *MiddlewareDesc

func genkit.DefineMiddleware[M ai.Middleware](g *Genkit, description string, prototype M) *ai.MiddlewareDesc
func genkit.LookupMiddleware(g *Genkit, name string) *ai.MiddlewareDesc

// MiddlewareFunc adapts a per-call factory closure to the Middleware interface
// for ad-hoc inline middleware, without a registered descriptor or plugin wiring.
type MiddlewareFunc func(ctx context.Context) (*Hooks, error)

// WithUse attaches middleware to a Generate call. Accepts either a middleware
// config struct or a MiddlewareFunc adapter. The chain applies outer-to-inner.
func WithUse(middleware ...Middleware) CommonGenOption

// MiddlewarePlugin is implemented by plugins that provide middleware.
// Middlewares() is called during genkit.Init; returned descriptors become
// visible to the Dev UI and are reachable via the reflection API.
type MiddlewarePlugin interface {
    Middlewares(ctx context.Context) ([]*MiddlewareDesc, error)
}